(function (window) {
    // 将状态声明为常量。全局（应用）性质的常量一般要求大写。
    const PENDING = "pending";
    const FULFILLED = "fulfilled";
    const REJECTED = "rejected"
    // 定义了一个构造函数，该构造函数接收执行器函数(executor)
    function Promise(executor) {
        // 增加实例属性state，初始值为pending
        this.state = PENDING;
        // 增加实例属性result,初始值为undefined
        this.result = undefined;
        // 增加属性,类型是一个数组,数组的元素类型写成对象,对象中拥有成功与失败的回调.
        this.callbackArr =[];
        const _resolve = value => {
            // 如果状态发生变化，那么后续代码不会执行
            if (this.state !== PENDING) return;
            // 将当前的状态更改为fulfilled,值为接收的value
            this.state = FULFILLED;
            this.result = value;
            

            // 遍历数组 callbackArr
            this.callbackArr.forEach(v=>v.onResolved());
        }
        const _reject = value => {
            // 如果状态发生变化，那么后续代码不会执行
            if (this.state !== PENDING) return;
            // 将当前的状态更改为rejected,值为接收的value
            this.state = REJECTED;
            this.result = value;
            // 遍历数组 callbackArr
            this.callbackArr.forEach(v=>v.onRejected());
        }
        try {
            executor(_resolve, _reject);
        } catch (err) {
            // 如果状态发生变化，那么后续代码不会执行
            _reject(err)
        }
    }
    Object.assign(Promise.prototype, {
        // 1- 接收两个回调函数（onResolved成功回调，onRejected失败回调）
        // 2- 如果状态为成功，则调用onResolved函数
        // 3- 如果状态为失败，则调用onRejected函数
        then(onResolved, onRejected) {
            // 判断onResolved是否为一个函数,如果不是函数,可以设置默认值
            if(!(onResolved instanceof Function)) onResolved = value=> value;
            // 判断onRejected是否为一个函数,如果不是函数,那么设置默认值
            if(!(onRejected instanceof Function)){
                onRejected = reason => {
                    throw reason;
                }
            }
            // 返回一个新的promise,在执行器函数中直接判断状态调用对应的成功或失败回调
            // 根据成功或失败回调的返回结果，来修改返回promise的状态以及值。
            return new Promise((resolve, reject) => {
                function _common(callback) {
                    setTimeout(() => {
                        // 将成功回调的返回值赋值给常量value
                        try {
                            const value = callback(this.result);// 调用成功回调，并将成功值传递过去
                            // 判断value是否为Promise实例
                            if (value instanceof Promise) value.then(resolve, reject)
                            else resolve(value);
                        } catch (err) {
                            // 有异常,，将返回的新的Promise的状态更改为失败，值为异常信息
                            reject(err);
                        }
                    })
                }
                // 判断状态是否为成功
                if (this.state === FULFILLED) {
                    _common.call(this, onResolved);
                } else if (this.state === REJECTED) {
                    _common.call(this, onRejected);
                } else if(this.state === PENDING){
                    // 增加callbackObj属性,用于保存更改状态后要调用的回调函数.
                    // this.callbackObj = {
                    //     onResolved:_common.bind(this,onResolved),
                    //     onRejected:_common.bind(this,onRejected)
                    // }

                    this.callbackArr.push({
                        onResolved:_common.bind(this,onResolved),
                        onRejected:_common.bind(this,onRejected)
                    })
                }
            })
        },
        catch(onRejected) {
            return this.then(undefined,onRejected)
        }
    })
    window.Promise = Promise;
})(window);